package whu.cn.whushare.net;

import android.content.Context;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.Volley;
import com.androidplus.net.HttpRequest;
import com.google.gson.reflect.TypeToken;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import whu.cn.whushare.bean.Result;
import whu.cn.whushare.bean.User;
import whu.cn.whushare.common.UserManager;
import whu.cn.whushare.ui.main.activity.bean.ActivityDetail;
import whu.cn.whushare.ui.main.activity.bean.AllActivity;
import whu.cn.whushare.ui.main.known.bean.AllQuestion;
import whu.cn.whushare.ui.main.known.bean.AnswerWrapBean;
import whu.cn.whushare.ui.main.known.bean.CommentWrapper;
import whu.cn.whushare.ui.main.known.bean.CommitBean;
import whu.cn.whushare.ui.main.known.bean.FavorBean;
import whu.cn.whushare.ui.main.known.bean.QuestionDetail;
import whu.cn.whushare.ui.main.activity.bean.SearchActivity;
import whu.cn.whushare.ui.main.known.bean.SearchQuestion;
import whu.cn.whushare.ui.main.known.bean.VoteBean;
import whu.cn.whushare.ui.main.my.MyAllTopic;
import whu.cn.whushare.ui.main.my.bean.AllTopic;
import whu.cn.whushare.ui.main.my.bean.MyActivity;
import whu.cn.whushare.ui.main.my.bean.MyAnswer;
import whu.cn.whushare.ui.main.my.bean.MyDynamic;
import whu.cn.whushare.ui.main.my.bean.MyQuestion;

import static whu.cn.whushare.net.DownloadParams.*;
import static whu.cn.whushare.net.DownloadParams.EMAIL;

/**
 * 类 名：downloader
 * 功 能：包含与网络相关的操作，如发送验证码、登录、更改密码等
 */
public class Downloader {
	private Context mContext;
	private RequestQueue mQueue;
	private static Downloader instance;

    //构造函数，获取当前应用程序的context信息，并创建一个网络请求队列，用于处理网络请求
	private Downloader(Context context) {
		mContext = context.getApplicationContext();
		mQueue = Volley.newRequestQueue(mContext);
	}

    //获取Downloader类实例
	public static Downloader getInstance(Context context) {
		if (instance == null) {
			synchronized (Downloader.class) {
				if (instance == null) {
					instance = new Downloader(context);
				}
			}
		}
		return instance;
	}

    /**
     * 发送验证码
     * @param userName - 当前应用程序登录用户名
     * @param type - 网络请求类型
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void sendIdCode(String userName, int type, NetResponseListener response) {
		Map<String, String> params = new HashMap<>();
		params.put(USER_NAME, userName);
		params.put(TYPE, String.valueOf(type));
        //创建一个发送验证码的网络请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_GET,
				PARSING_TYPE.SEND_ID_CODE_URL, params, response, new TypeToken<Result<String>>() {
				}, null);

		mQueue.add(request);
		mQueue.start();
	}

    /**
     * 发送邮件
     * @param email - 邮箱地址
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void sendEmail(String email, NetResponseListener response) {
		Map<String, String> params = new HashMap<>();
		params.put(EMAIL, email);

        //创建一个发送邮件的网络请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.SEND_EMAIL,params, response, new TypeToken<Result<String>>() {
				}, null);

		mQueue.add(request);

	}

    /**
     * 登录
     * @param userName - 待登录用户名
     * @param pass - 登录密码
     * @param type - 登录类型，包括邮箱登录和手机号登录两种形式
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj -
     */
	public void login(String userName, String pass, int type, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put(USER_NAME, userName);
		params.put(PASS, pass);
		params.put(TYPE, type + "");

        //创建一个登录请求
		CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.LOGIN_URL,
				params, response, new TypeToken<Result<User>>() {
				}, obj);

		start(request);
	}

    /**
     * 更改昵称
     * @param nickName - 用户输入的昵称
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void changeNickName(String nickName, NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("nickname", nickName);

        //创建一个更改昵称的请求
        CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.CHANGE_NICKNAME,
                params, response, new TypeToken<Result<User>>() {
        }, null);

        start(request);
    }

    /**
     * 更改性别
     * @param gender - 用户输入的性别
     * @param response- 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void changeGender(String gender, NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("gender", gender);

        //创建一个更改性别的网络请求
        CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.CHANGE_GENDER,
                params, response, new TypeToken<Result<User>>() {
        }, null);

        start(request);
    }

    /**
     * 更改手机号
     * @param phone - 用户输入的手机号
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void changePhone(String phone, NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("phonenumber", phone);

        //创建一个更改手机号的网络请求
        CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.CHANGE_PHONE,
                params, response, new TypeToken<Result<User>>() {
        }, null);

        start(request);
    }

    /**
     * 更改职称
     * @param position - 用户输入的职称
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void changeTitle(String position, NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("position", position);

        //创建一个更改职称的网络请求
        CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.CHANGE_TITLE,
                params, response, new TypeToken<Result<User>>() {
        }, null);

        start(request);
    }

    /**
     * 更改Autograph
     * @param autograph - autograph
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void changeAutograph(String autograph, NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("autograph", autograph);

        //创建一个更改autograph的网络请求
        CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.CHANGE_TITLE,
                params, response, new TypeToken<Result<User>>() {
        }, null);

        start(request);
    }

    /**
     * 注册
     * @param userName - 注册用户名
     * @param pass - 注册密码
     * @param email - 注册邮箱
     * @param phone - 注册手机号
     * @param nickname - 注册昵称
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void register(String userName, String pass, String email, String phone,String nickname, NetResponseListener response) {
		Map<String, String> params = getCommonParams();
		params.put(USER_NAME, userName);
		params.put(PASS, pass);
		params.put(EMAIL, email);
        params.put(NICKNAME,nickname);
        params.put(PHONE,phone);
	//	params.put(TYPE, type + "");

        //创建一个注册请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.REGISTER_URL, params, response, new TypeToken<Result<String>>() {
				}, null);

		start(request);
	}

    /**
     * 开启请求队列
     * @param request  - 需要被添加到请求队列中的网络请求
     */
	private <T> void start(CommonRequest<T> request) {
		mQueue.add(request);
		mQueue.start();
	}

    /**
     * 获取用户信息
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getUserInfo(NetResponseListener response, Object obj) {
        //创建一个用于获取用户信息的网络请求
		CommonRequest<User> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.USER_INFO_URL, getCommonParams(), response, new TypeToken<Result<User>>() {
				}, obj);
		start(request);
	}

    /**
     * 获取当前用户指定页面问题列表信息
     * @param page - 指定的问题列表页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getMyQuestionList(int page, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("page", page + "");
        params.put("page_size",  "5");

        //创建一个用于获取当前用户指定页面问题列表信息的网络请求
        CommonRequest<MyQuestion> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_QUESTION, params, response, new TypeToken<Result<MyQuestion>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取当前登录用户指定页面的问题回答列表信息
     * @param page - 指定的回答列表页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getMyAnswerList(int page, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("page", page + "");
        params.put("page_size",  "5");

        //创建一个用于获取当前登录用户指定页面的问题回答列表信息的网络请求
        CommonRequest<List<MyAnswer>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_ANSWER, params, response, new TypeToken<Result<List<MyAnswer>>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取当前登录用户指定页面的活动列表
     * @param page - 指定的活动列表页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getMyActivityList(int page, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("page", page + "");
        params.put("page_size",  "5");
        CommonRequest<MyActivity> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_ACTIVITY, params, response, new TypeToken<Result<MyActivity>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取当前登录用户的动态列表
     * @param page - 页面
     * @param pageSize - 页面大小
     * @param dynamicId - 动态id
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getMyDynamicList(int page,int pageSize,String dynamicId, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("page", page + "");
        params.put("pageSize", pageSize+"");
        params.put("dynamicId",dynamicId+"");

        //创建一个获取当前登录用户动态列表的网络请求
        CommonRequest<List<MyDynamic>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_DYNAMIC, params, response, new TypeToken<Result<List<MyDynamic>>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取当前用户关注的话题
     * @param page - 页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getMyTopic(int page, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("page", page + "");
        params.put("pageSize",  "6");

        //创建一个获取当前登录用户所关注的话题的网络请求
        CommonRequest<List<AllTopic>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_TOPIC, params, response, new TypeToken<Result<List<AllTopic>>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取指定话题的问题列表
     * @param topicId - 话题id
     * @param page - 页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getTopicQuestionList(String topicId ,int page, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("topicId",topicId);
        params.put("page", page + "");
        params.put("pageSize",  "5");

        //创建一个获取指定话题的问题列表的网络请求
        CommonRequest<List<AllQuestion>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.MY_TOPIC_DETAIL, params, response, new TypeToken<Result<List<AllQuestion>>>() {
        }, obj);
        start(request);
    }

    /**
     * 设置密码
     * @param sPassword - 旧密码
     * @param ePassword - 新密码
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void setPassword(String sPassword, String ePassword, NetResponseListener response) {
		Map<String, String> params = getCommonParams();
		params.put("input-password-old", sPassword);
		params.put("input-password-re-new", ePassword);

        //创建一个设置密码的网路请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.EDIT_PASSWORD, params, response, new TypeToken<Result<String>>() {
				}, null);
		start(request);
	}

    /**
     * 获取网络响应公共参数列表
     * @return 参数列表
     */
	private Map<String, String> getCommonParams() {
		Map<String, String> params = new HashMap<>();
		User user = UserManager.getInstance(mContext).getCurrentUser();
		if (user != User.Null) {
           params.put("uid",user.getId());
           params.put(USER_ID,user.getId());
           params.put("c_uid",user.getId());
           params.put("user_id",user.getId());
           params.put(TOKEN, user.getToken());
		}

		params.put(PAGE, "1");
		params.put(PAGE_SIZE, "5");
		params.put(CLIENT, "android");
		params.put(VERSION, "1.0");
		return params;
	}

    /**
     * 获取所有问题列表
     * @param page - 页面
     * @param pageSize - 页面大小
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getAllQuestionList(int page, int pageSize, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
        params.put("page", page + "");
		params.put("page_size", pageSize + "");

        //创建一个用于获取所有问题列表的网络请求
		CommonRequest<List<AllQuestion>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.ALL_QUESTION_LIST, params, response, new TypeToken<Result<List<AllQuestion>>>() {
				}, obj);
		start(request);
	}

    /**
     * 获取查询问题列表
     * @param ques - 查询问题
     * @param page - 页面
     * @param pageSize - 页面大小
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getQueryQuestionsList(String ques, int page, int pageSize, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put("q", ques);
		params.put("page", page + "");
		params.put("page_size", pageSize + "");
		params.put("type", "question");

        //创建一个用于获取查询问题列表的网络请求
		CommonRequest<List<SearchQuestion>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.QUERY_QUESTION_ACTIVITY, params, response, new TypeToken<Result<List<SearchQuestion>>>() {
				}, obj);
		start(request);
	}

    /**
     * 获取查询活动列表
     * @param ques - 查询问题
     * @param page - 页面
     * @param pageSize - 页面大小
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
    public void getQueryActivitiesList(String ques, int page, int pageSize, NetResponseListener response, Object obj) {
        Map<String, String> params = getCommonParams();
        params.put("q", ques);
        params.put("page", page + "");
        params.put("page_size", pageSize + "");
        params.put("type", "activity");

        //创建一个用于获取查询活动列表的网络请求
        CommonRequest<List<SearchActivity>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.QUERY_QUESTION_ACTIVITY, params, response, new TypeToken<Result<List<SearchActivity>>>() {
        }, obj);
        start(request);
    }

    /**
     * 获取问题详情
     * @param id - 问题id
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getQuestionDetail(String id, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put(QUESTION_ID, id);

        //创建一个用于获取问题详情的网络请求
		CommonRequest<QuestionDetail> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.QUESTION_DETAIL, params, response, new TypeToken<Result<QuestionDetail>>() {
				}, obj);

		start(request);
	}

    /**
     * 获取问题数
     * @param id
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getQuestionCount(String id, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put("questionId", id);

        //创建一个用于获取问题数的网络请求
		CommonRequest<Integer> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.QUESTION_COUNT, params, response, new TypeToken<Result<Integer>>() {
				}, obj);

		start(request);
	}

    /**
     * 获取指定问题的回答列表
     * @param id - 问题id
     * @param sortKey - 排序方式
     * @param sort - 排序
     * @param page - 页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getAnswerList(String id, String sortKey, String sort, int page, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put(QUESTION_ID, id);
		params.put("sort_key", sortKey);
		params.put("sort", sort);
		params.put("page", page + "");
		params.put("pageSize", "15");

        //创建一个用于获取问题回答列表的网络请求
		CommonRequest<List<AnswerWrapBean>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.ANSWER_DETAIL, params, response, new TypeToken<Result<List<AnswerWrapBean>>>() {
				}, obj);

		start(request);
	}

    /**
     * 请求收藏指定问题
     * @param id - 问题id
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void requestFavor(String id, NetResponseListener responseListener) {
		Map<String, String> params = getCommonParams();
		params.put("question_id", id);

        //创建一个请求收藏指定问题的网络请求
		CommonRequest<FavorBean> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.FAVOR,
				params, responseListener, new TypeToken<Result<FavorBean>>() {
				}, null);

		start(request);
	}

    /**
     * 请求将指定话题设置为喜爱话题
     * @param id - 话题id
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void requestFavorTopic(String id,NetResponseListener responseListener) {
        Map<String, String> params = getCommonParams();
        params.put("topicId",id);

        //创建一个请求设置喜爱话题的网络请求
        CommonRequest<FavorBean> request = new CommonRequest<>(mContext,HttpRequest.METHOD_POST ,PARSING_TYPE.FAVOR1 ,
                params, responseListener, new TypeToken<Result<FavorBean>>() {
        }, null);

        start(request);
    }

    /**
     * 请求加入指定活动
     * @param id - 活动id
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void requestSign(String id, NetResponseListener responseListener) {
        Map<String, String> params = getCommonParams();
        params.put("activity_id", id);

        //创建一个请求加入某活动的网络请求
        CommonRequest<FavorBean> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.SIGN,
                params, responseListener, new TypeToken<Result<FavorBean>>() {
        }, null);

        start(request);
    }

    /**
     * 请求对指定回答进行投票
     * @param id - 回答id
     * @param vote - 投票
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void requestVote(String id, int vote, NetResponseListener responseListener) {
		Map<String, String> params = getCommonParams();
		params.put("answer_id", id);
		params.put("value", vote + "");

        //创建一个用于请求投票的网络请求
		CommonRequest<VoteBean> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.VOTE,
				params, responseListener, new TypeToken<Result<VoteBean>>() {
				}, null);

		start(request);
	}

    /**
     * 为指定问题添加答案
     * @param id - 问题id
     * @param content - 答案内容
     * @param autoFocus - 自动关注
     * @param anonymous - 是否匿名回答
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void addAnswer(String id, String content, int autoFocus, boolean anonymous,
			NetResponseListener responseListener) {
		Map<String, String> params = getCommonParams();
		params.put("question_id", id);
		params.put("answer_content", content);
		params.put("auto_focus", autoFocus + "");
		params.put("anonymous", "0");

        //创建一个用于添加答案的网络请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.ADD_ANSWER,
				params, responseListener, new TypeToken<Result<String>>() {
				}, null);
		start(request);
	}

    /**
     * 为指定问题的指定回答添加评论
     * @param qid - 问题id
     * @param aid - 回答id
     * @param content - 评论内容
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
	public void addComment(String qid, String aid, String content, NetResponseListener responseListener) {
		Map<String, String> params = getCommonParams();
		params.put("question_id", qid);
		params.put("answer_id", aid);
		params.put("message", content);

        //创建一个拥有添加评论的网络请求
		CommonRequest<CommitBean> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.ADD_COMMENT, params, responseListener, new TypeToken<Result<CommitBean>>() {
				}, null);
		start(request);
	}

    /**
     * 获取指定id的问题回答的评论
     * @param id - 问题回答的id
     * @param responseListener
     */
	public void getComments(String id, NetResponseListener responseListener) {
		Map<String, String> params = getCommonParams();
		params.put("answer_id", id);

        //创建一个用于获取指定id问题回答的评论的网络请求
		CommonRequest<List<CommentWrapper>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.COMMENTS, params, responseListener, new TypeToken<Result<List<CommentWrapper>>>() {
				}, null);
		start(request);
	}

    /**
     * 获取所有活动列表
     * @param page - 页面
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getAllActivityList(int page, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();

		params.put("page", page + "");
		params.put("page_size", "7");

        //创建一个用于获取指定页面所有活动的网络请求
		CommonRequest<List<AllActivity>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.ALL_ACTIVITY_LIST, params, response, new TypeToken<Result<List<AllActivity>>>() {
				}, obj);
		start(request);
	}

    /**
     * 获取指定id的活动详情信息
     * @param id - 活动id
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getActivityDetail(String id, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put(ACTIVITY_ID, id);

        //创建一个用于获取指定id的活动详情信息的网络请求
		CommonRequest<ActivityDetail> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.ACTIVITY_DETAIL, params, response, new TypeToken<Result<ActivityDetail>>() {
				}, obj);
		start(request);
	}

    /**
     * 获取活动参与用户列表
     * @param id - 活动id
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void getSignUserList(String id, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put(ACTIVITY_ID, id);

        //创建一个用于获取sign用户列表的网络请求
		CommonRequest<List<User>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.SIGN_USER_LIST, params, response, new TypeToken<Result<List<User>>>() {
				}, obj);
		start(request);
	}

    /**
     * 打印问题
     * @param content - 问题内容
     * @param detail - 问题详情
     * @param topic - 话题
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void publishQuestion(String content, String detail, String topic, NetResponseListener response, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put("question_content", content);
		params.put("question_detail", detail);
		params.put("topics[]", topic);

        //创建一个用于打印问题的网络请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.PUBLISH_QUESTION, params, response, new TypeToken<Result<String>>() {
				}, obj);
		start(request);
	}

    /**
     * 搜索满足指定条件的用户列表
     * @param q - 搜索条件
     * @param page - 页面
     * @param pageSize - 页面大小
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void searchUser(String q, int page, int pageSize, NetResponseListener responseListener, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put("q", q);
		params.put("page", page + "");
		params.put("page_size", pageSize + "");
		params.put("type", "user");

        //创建一个用于搜索用户列表的网络请求
		CommonRequest<List<User>> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
				PARSING_TYPE.SEARCH_USER, params, responseListener, new TypeToken<Result<List<User>>>() {
				}, obj);
		start(request);
	}

    /**
     * 保存邀请信息
     * @param qid - 被邀请回答的问题id
     * @param uid - 被邀请的用户id
     * @param responseListener - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     * @param obj
     */
	public void saveInvite(String qid, String uid, NetResponseListener responseListener, Object obj) {
		Map<String, String> params = getCommonParams();
		params.put("question_id", qid);
		params.put("invite_user_id", uid);

        //创建一个用于保存邀请信息的网络请求
		CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST, PARSING_TYPE.INVITE,
				params, responseListener, new TypeToken<Result<String>>() {
				}, obj);
		start(request);
	}

    /**
     * 发起一个活动
     * @param activityName - 活动名
     * @param activityDetail - 活动详情
     * @param endTime - 活动结束时间
     * @param hostTime - 活动举办时间
     * @param address - 活动地点
     * @param response - 网络请求响应监听器，用于对服务器返回的网络响应进行处理
     */
    public void launchActivity(String activityName, String activityDetail, String endTime,
                               String hostTime,String address,NetResponseListener response) {
        Map<String, String> params = getCommonParams();
        params.put("activity_name", activityName);
        params.put("activity_detail", activityDetail);
        params.put("activity_end_time", endTime);
        params.put( "activity_host_time", hostTime);
        params.put("activity_address",address);

        //创建一个用于发起活动的网络请求
        CommonRequest<String> request = new CommonRequest<>(mContext, HttpRequest.METHOD_POST,
                PARSING_TYPE.LAUNCH_ACTIVITY, params, response, new TypeToken<Result<String>>() {
        }, null);

        start(request);
    }


}
